#include "stdafx.h"
#include "UIScrollBar.h"

namespace DuiLib
{

    CScrollBarUI::CScrollBarUI() :
        m_bHorizontal(false),
        m_nRange(100),
        m_nScrollPos(0),
        m_nLineSize(SCROLLBAR_LINESIZE),
        m_nScrollUnit(1),
        m_pOwner(NULL),
        m_nLastScrollPos(0),
        m_nLastScrollOffset(0),
        m_nScrollRepeatDelay(0),
        m_dwButton1Color(0),
        m_uButton1State(0),
        m_dwButton2Color(0),
        m_uButton2State(0),
        m_dwThumbColor(0),
        m_uThumbState(0),
        m_bShowButton1(true),
        m_bShowButton2(true)
    {
        m_cxyFixed.cx = DEFAULT_SCROLLBAR_SIZE;
        ptLastMouse.x = ptLastMouse.y = 0;
        ::ZeroMemory(&m_rcThumb, sizeof(m_rcThumb));
        ::ZeroMemory(&m_rcButton1, sizeof(m_rcButton1));
        ::ZeroMemory(&m_rcButton2, sizeof(m_rcButton2));
    }

    LPCTSTR CScrollBarUI::GetClass() const
    {
        return DUI_CTR_SCROLLBAR;
    }

    LPVOID CScrollBarUI::GetInterface(LPCTSTR pstrName)
    {
        if (_tcscmp(pstrName, DUI_CTR_SCROLLBAR) == 0) return static_cast<CScrollBarUI*>(this);
        return CControlUI::GetInterface(pstrName);
    }

    CContainerUI* CScrollBarUI::GetOwner() const
    {
        return m_pOwner;
    }

    void CScrollBarUI::SetOwner(CContainerUI* pOwner)
    {
        m_pOwner = pOwner;
    }

    void CScrollBarUI::SetVisible(bool bVisible)
    {
        if (m_bVisible == bVisible) return;

        bool v = IsVisible();
        m_bVisible = bVisible;
        if (m_bFocused) m_bFocused = false;
    }

    void CScrollBarUI::SetEnabled(bool bEnable)
    {
        CControlUI::SetEnabled(bEnable);
        if (!IsEnabled())
        {
            m_uButton1State = 0;
            m_uButton2State = 0;
            m_uThumbState = 0;
        }
    }

    void CScrollBarUI::SetFocus()
    {
        if (m_pOwner != NULL) m_pOwner->SetFocus();
        else CControlUI::SetFocus();
    }

    bool CScrollBarUI::IsHorizontal()
    {
        return m_bHorizontal;
    }

    void CScrollBarUI::SetHorizontal(bool bHorizontal)
    {
        if (m_bHorizontal == bHorizontal) return;

        m_bHorizontal = bHorizontal;
        if (m_bHorizontal)
        {
            if (m_cxyFixed.cy == 0)
            {
                m_cxyFixed.cx = 0;
                m_cxyFixed.cy = DEFAULT_SCROLLBAR_SIZE;
            }
        }
        else
        {
            if (m_cxyFixed.cx == 0)
            {
                m_cxyFixed.cx = DEFAULT_SCROLLBAR_SIZE;
                m_cxyFixed.cy = 0;
            }
        }

        if (m_pOwner != NULL) m_pOwner->NeedUpdate(); else NeedParentUpdate();
    }

    int CScrollBarUI::GetScrollRange() const
    {
        return m_nRange;
    }

    void CScrollBarUI::SetScrollRange(int nRange)
    {
        if (m_nRange == nRange) return;

        m_nRange = nRange;
        if (m_nRange < 0) m_nRange = 0;
        if (m_nScrollPos > m_nRange) m_nScrollPos = m_nRange;
        SetPos(m_rcItem, true);
    }

    int CScrollBarUI::GetScrollPos() const
    {
        return m_nScrollPos;
    }

    void CScrollBarUI::SetScrollPos(int nPos, bool bTriggerEvent)
    {
        if (m_nScrollPos == nPos) return;

        int iOldScrollPos = m_nScrollPos;
        m_nScrollPos = nPos;
        if (m_nScrollPos < 0) m_nScrollPos = 0;
        if (m_nScrollUnit > 1)
        {
            int iLeftOffset = m_nScrollPos % m_nScrollUnit;
            if (iLeftOffset != 0)
            {
                if (iLeftOffset >= m_nScrollUnit / 2) m_nScrollPos += m_nScrollUnit - iLeftOffset;
                else m_nScrollPos -= iLeftOffset;
            }
        }
        if (m_nScrollPos > m_nRange) m_nScrollPos = m_nRange;

        SetPos(m_rcItem, true);

        if (bTriggerEvent && m_pManager != NULL)
            m_pManager->SendNotify(this, DUI_MSGTYPE_SCROLL, m_nScrollPos, iOldScrollPos, true, false);
    }

    int CScrollBarUI::GetLineSize() const
    {
        if (m_nScrollUnit > 1) return m_nScrollUnit;
        return m_nLineSize;
    }

    void CScrollBarUI::SetLineSize(int nSize)
    {
        if (nSize >= 0) m_nLineSize = nSize;
    }

    int CScrollBarUI::GetScrollUnit() const
    {
        return m_nScrollUnit;
    }

    void CScrollBarUI::SetScrollUnit(int iUnit)
    {
        if (iUnit >= 0) m_nScrollUnit = iUnit;
    }

    bool CScrollBarUI::GetShowButton1()
    {
        return m_bShowButton1;
    }

    void CScrollBarUI::SetShowButton1(bool bShow)
    {
        m_bShowButton1 = bShow;
        SetPos(m_rcItem, true);
    }

    DWORD CScrollBarUI::GetButton1Color() const
    {
        return m_dwButton1Color;
    }

    void CScrollBarUI::SetButton1Color(DWORD dwColor)
    {
        if (m_dwButton1Color == dwColor) return;
        m_dwButton1Color = dwColor;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetButton1NormalImage()
    {
        return m_diButton1Normal.sDrawString;
    }

    void CScrollBarUI::SetButton1NormalImage(LPCTSTR pStrImage)
    {
        if (m_diButton1Normal.sDrawString == pStrImage && m_diButton1Normal.pImageInfo != NULL) return;
        m_diButton1Normal.Clear();
        m_diButton1Normal.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetButton1HotImage()
    {
        return m_diButton1Hot.sDrawString;
    }

    void CScrollBarUI::SetButton1HotImage(LPCTSTR pStrImage)
    {
        if (m_diButton1Hot.sDrawString == pStrImage && m_diButton1Hot.pImageInfo != NULL) return;
        m_diButton1Hot.Clear();
        m_diButton1Hot.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetButton1PushedImage()
    {
        return m_diButton1Pushed.sDrawString;
    }

    void CScrollBarUI::SetButton1PushedImage(LPCTSTR pStrImage)
    {
        if (m_diButton1Pushed.sDrawString == pStrImage && m_diButton1Pushed.pImageInfo != NULL) return;
        m_diButton1Pushed.Clear();
        m_diButton1Pushed.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetButton1DisabledImage()
    {
        return m_diButton1Disabled.sDrawString;
    }

    void CScrollBarUI::SetButton1DisabledImage(LPCTSTR pStrImage)
    {
        if (m_diButton1Disabled.sDrawString == pStrImage && m_diButton1Disabled.pImageInfo != NULL) return;
        m_diButton1Disabled.Clear();
        m_diButton1Disabled.sDrawString = pStrImage;
        Invalidate();
    }

    bool CScrollBarUI::GetShowButton2()
    {
        return m_bShowButton2;
    }

    void CScrollBarUI::SetShowButton2(bool bShow)
    {
        m_bShowButton2 = bShow;
        SetPos(m_rcItem, true);
    }

    DWORD CScrollBarUI::GetButton2Color() const
    {
        return m_dwButton2Color;
    }

    void CScrollBarUI::SetButton2Color(DWORD dwColor)
    {
        if (m_dwButton2Color == dwColor) return;
        m_dwButton2Color = dwColor;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetButton2NormalImage()
    {
        return m_diButton2Normal.sDrawString;
    }

    void CScrollBarUI::SetButton2NormalImage(LPCTSTR pStrImage)
    {
        if (m_diButton2Normal.sDrawString == pStrImage && m_diButton2Normal.pImageInfo != NULL) return;
        m_diButton2Normal.Clear();
        m_diButton2Normal.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetButton2HotImage()
    {
        return m_diButton2Hot.sDrawString;
    }

    void CScrollBarUI::SetButton2HotImage(LPCTSTR pStrImage)
    {
        if (m_diButton2Hot.sDrawString == pStrImage && m_diButton2Hot.pImageInfo != NULL) return;
        m_diButton2Hot.Clear();
        m_diButton2Hot.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetButton2PushedImage()
    {
        return m_diButton2Pushed.sDrawString;
    }

    void CScrollBarUI::SetButton2PushedImage(LPCTSTR pStrImage)
    {
        if (m_diButton2Pushed.sDrawString == pStrImage && m_diButton2Pushed.pImageInfo != NULL) return;
        m_diButton2Pushed.Clear();
        m_diButton2Pushed.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetButton2DisabledImage()
    {
        return m_diButton2Disabled.sDrawString;
    }

    void CScrollBarUI::SetButton2DisabledImage(LPCTSTR pStrImage)
    {
        if (m_diButton2Disabled.sDrawString == pStrImage && m_diButton2Disabled.pImageInfo != NULL) return;
        m_diButton2Disabled.Clear();
        m_diButton2Disabled.sDrawString = pStrImage;
        Invalidate();
    }

    DWORD CScrollBarUI::GetThumbColor() const
    {
        return m_dwThumbColor;
    }

    void CScrollBarUI::SetThumbColor(DWORD dwColor)
    {
        if (m_dwThumbColor == dwColor) return;
        m_dwThumbColor = dwColor;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetThumbNormalImage()
    {
        return m_diThumbNormal.sDrawString;
    }

    void CScrollBarUI::SetThumbNormalImage(LPCTSTR pStrImage)
    {
        if (m_diThumbNormal.sDrawString == pStrImage && m_diThumbNormal.pImageInfo != NULL) return;
        m_diThumbNormal.Clear();
        m_diThumbNormal.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetThumbHotImage()
    {
        return m_diThumbHot.sDrawString;
    }

    void CScrollBarUI::SetThumbHotImage(LPCTSTR pStrImage)
    {
        if (m_diThumbHot.sDrawString == pStrImage && m_diThumbHot.pImageInfo != NULL) return;
        m_diThumbHot.Clear();
        m_diThumbHot.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetThumbPushedImage()
    {
        return m_diThumbPushed.sDrawString;
    }

    void CScrollBarUI::SetThumbPushedImage(LPCTSTR pStrImage)
    {
        if (m_diThumbPushed.sDrawString == pStrImage && m_diThumbPushed.pImageInfo != NULL) return;
        m_diThumbPushed.Clear();
        m_diThumbPushed.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetThumbDisabledImage()
    {
        return m_diThumbDisabled.sDrawString;
    }

    void CScrollBarUI::SetThumbDisabledImage(LPCTSTR pStrImage)
    {
        if (m_diThumbDisabled.sDrawString == pStrImage && m_diThumbDisabled.pImageInfo != NULL) return;
        m_diThumbDisabled.Clear();
        m_diThumbDisabled.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetRailNormalImage()
    {
        return m_diRailNormal.sDrawString;
    }

    void CScrollBarUI::SetRailNormalImage(LPCTSTR pStrImage)
    {
        if (m_diRailNormal.sDrawString == pStrImage && m_diRailNormal.pImageInfo != NULL) return;
        m_diRailNormal.Clear();
        m_diRailNormal.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetRailHotImage()
    {
        return m_diRailHot.sDrawString;
    }

    void CScrollBarUI::SetRailHotImage(LPCTSTR pStrImage)
    {
        if (m_diRailHot.sDrawString == pStrImage && m_diRailHot.pImageInfo != NULL) return;
        m_diRailHot.Clear();
        m_diRailHot.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetRailPushedImage()
    {
        return m_diRailPushed.sDrawString;
    }

    void CScrollBarUI::SetRailPushedImage(LPCTSTR pStrImage)
    {
        if (m_diRailPushed.sDrawString == pStrImage && m_diRailPushed.pImageInfo != NULL) return;
        m_diRailPushed.Clear();
        m_diRailPushed.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetRailDisabledImage()
    {
        return m_diRailDisabled.sDrawString;
    }

    void CScrollBarUI::SetRailDisabledImage(LPCTSTR pStrImage)
    {
        if (m_diRailDisabled.sDrawString == pStrImage && m_diRailDisabled.pImageInfo != NULL) return;
        m_diRailDisabled.Clear();
        m_diRailDisabled.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetBkNormalImage()
    {
        return m_diBkNormal.sDrawString;
    }

    void CScrollBarUI::SetBkNormalImage(LPCTSTR pStrImage)
    {
        if (m_diBkNormal.sDrawString == pStrImage && m_diBkNormal.pImageInfo != NULL) return;
        m_diBkNormal.Clear();
        m_diBkNormal.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetBkHotImage()
    {
        return m_diBkHot.sDrawString;
    }

    void CScrollBarUI::SetBkHotImage(LPCTSTR pStrImage)
    {
        if (m_diBkHot.sDrawString == pStrImage && m_diBkHot.pImageInfo != NULL) return;
        m_diBkHot.Clear();
        m_diBkHot.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetBkPushedImage()
    {
        return m_diBkPushed.sDrawString;
    }

    void CScrollBarUI::SetBkPushedImage(LPCTSTR pStrImage)
    {
        if (m_diBkPushed.sDrawString == pStrImage && m_diBkPushed.pImageInfo != NULL) return;
        m_diBkPushed.Clear();
        m_diBkPushed.sDrawString = pStrImage;
        Invalidate();
    }

    LPCTSTR CScrollBarUI::GetBkDisabledImage()
    {
        return m_diBkDisabled.sDrawString;
    }

    void CScrollBarUI::SetBkDisabledImage(LPCTSTR pStrImage)
    {
        if (m_diBkDisabled.sDrawString == pStrImage && m_diBkDisabled.pImageInfo != NULL) return;
        m_diBkDisabled.Clear();
        m_diBkDisabled.sDrawString = pStrImage;
        Invalidate();
    }

    void CScrollBarUI::SetPos(RECT rc, bool bNeedInvalidate)
    {
        CControlUI::SetPos(rc, bNeedInvalidate);
        rc = m_rcItem;

        if (m_bHorizontal)
        {
            int cx = rc.right - rc.left;
            if (m_bShowButton1) cx -= m_cxyFixed.cy;
            if (m_bShowButton2) cx -= m_cxyFixed.cy;
            if (cx > m_cxyFixed.cy)
            {
                m_rcButton1.left = rc.left;
                m_rcButton1.top = rc.top;
                if (m_bShowButton1)
                {
                    m_rcButton1.right = rc.left + m_cxyFixed.cy;
                    m_rcButton1.bottom = rc.top + m_cxyFixed.cy;
                }
                else
                {
                    m_rcButton1.right = m_rcButton1.left;
                    m_rcButton1.bottom = m_rcButton1.top;
                }

                m_rcButton2.top = rc.top;
                m_rcButton2.right = rc.right;
                if (m_bShowButton2)
                {
                    m_rcButton2.left = rc.right - m_cxyFixed.cy;
                    m_rcButton2.bottom = rc.top + m_cxyFixed.cy;
                }
                else
                {
                    m_rcButton2.left = m_rcButton2.right;
                    m_rcButton2.bottom = m_rcButton2.top;
                }

                m_rcThumb.top = rc.top;
                m_rcThumb.bottom = rc.top + m_cxyFixed.cy;
                if (m_nRange > 0)
                {
                    int cxThumb = cx * (rc.right - rc.left) / (m_nRange + rc.right - rc.left);
                    if (cxThumb < m_cxyFixed.cy) cxThumb = m_cxyFixed.cy;

                    m_rcThumb.left = m_nScrollPos * (cx - cxThumb) / m_nRange + m_rcButton1.right;
                    m_rcThumb.right = m_rcThumb.left + cxThumb;
                    if (m_rcThumb.right > m_rcButton2.left)
                    {
                        m_rcThumb.left = m_rcButton2.left - cxThumb;
                        m_rcThumb.right = m_rcButton2.left;
                    }
                }
                else
                {
                    m_rcThumb.left = m_rcButton1.right;
                    m_rcThumb.right = m_rcButton2.left;
                }
            }
            else
            {
                int cxButton = (rc.right - rc.left) / 2;
                if (cxButton > m_cxyFixed.cy) cxButton = m_cxyFixed.cy;
                m_rcButton1.left = rc.left;
                m_rcButton1.top = rc.top;
                if (m_bShowButton1)
                {
                    m_rcButton1.right = rc.left + cxButton;
                    m_rcButton1.bottom = rc.top + m_cxyFixed.cy;
                }
                else
                {
                    m_rcButton1.right = m_rcButton1.left;
                    m_rcButton1.bottom = m_rcButton1.top;
                }

                m_rcButton2.top = rc.top;
                m_rcButton2.right = rc.right;
                if (m_bShowButton2)
                {
                    m_rcButton2.left = rc.right - cxButton;
                    m_rcButton2.bottom = rc.top + m_cxyFixed.cy;
                }
                else
                {
                    m_rcButton2.left = m_rcButton2.right;
                    m_rcButton2.bottom = m_rcButton2.top;
                }

                ::ZeroMemory(&m_rcThumb, sizeof(m_rcThumb));
            }
        }
        else
        {
            int cy = rc.bottom - rc.top;
            if (m_bShowButton1) cy -= m_cxyFixed.cx;
            if (m_bShowButton2) cy -= m_cxyFixed.cx;
            if (cy > m_cxyFixed.cx)
            {
                m_rcButton1.left = rc.left;
                m_rcButton1.top = rc.top;
                if (m_bShowButton1)
                {
                    m_rcButton1.right = rc.left + m_cxyFixed.cx;
                    m_rcButton1.bottom = rc.top + m_cxyFixed.cx;
                }
                else
                {
                    m_rcButton1.right = m_rcButton1.left;
                    m_rcButton1.bottom = m_rcButton1.top;
                }

                m_rcButton2.left = rc.left;
                m_rcButton2.bottom = rc.bottom;
                if (m_bShowButton2)
                {
                    m_rcButton2.top = rc.bottom - m_cxyFixed.cx;
                    m_rcButton2.right = rc.left + m_cxyFixed.cx;
                }
                else
                {
                    m_rcButton2.top = m_rcButton2.bottom;
                    m_rcButton2.right = m_rcButton2.left;
                }

                m_rcThumb.left = rc.left;
                m_rcThumb.right = rc.left + m_cxyFixed.cx;
                if (m_nRange > 0)
                {
                    int cyThumb = cy * (rc.bottom - rc.top) / (m_nRange + rc.bottom - rc.top);
                    if (cyThumb < m_cxyFixed.cx) cyThumb = m_cxyFixed.cx;

                    m_rcThumb.top = m_nScrollPos * (cy - cyThumb) / m_nRange + m_rcButton1.bottom;
                    m_rcThumb.bottom = m_rcThumb.top + cyThumb;
                    if (m_rcThumb.bottom > m_rcButton2.top)
                    {
                        m_rcThumb.top = m_rcButton2.top - cyThumb;
                        m_rcThumb.bottom = m_rcButton2.top;
                    }
                }
                else
                {
                    m_rcThumb.top = m_rcButton1.bottom;
                    m_rcThumb.bottom = m_rcButton2.top;
                }
            }
            else
            {
                int cyButton = (rc.bottom - rc.top) / 2;
                if (cyButton > m_cxyFixed.cx) cyButton = m_cxyFixed.cx;
                m_rcButton1.left = rc.left;
                m_rcButton1.top = rc.top;
                if (m_bShowButton1)
                {
                    m_rcButton1.right = rc.left + m_cxyFixed.cx;
                    m_rcButton1.bottom = rc.top + cyButton;
                }
                else
                {
                    m_rcButton1.right = m_rcButton1.left;
                    m_rcButton1.bottom = m_rcButton1.top;
                }

                m_rcButton2.left = rc.left;
                m_rcButton2.bottom = rc.bottom;
                if (m_bShowButton2)
                {
                    m_rcButton2.top = rc.bottom - cyButton;
                    m_rcButton2.right = rc.left + m_cxyFixed.cx;
                }
                else
                {
                    m_rcButton2.top = m_rcButton2.bottom;
                    m_rcButton2.right = m_rcButton2.left;
                }

                ::ZeroMemory(&m_rcThumb, sizeof(m_rcThumb));
            }
        }
    }

    void CScrollBarUI::DoEvent(TEventUI& event)
    {
        if (!IsMouseEnabled() && event.Type > UIEVENT__MOUSEBEGIN && event.Type < UIEVENT__MOUSEEND)
        {
            if (m_pOwner != NULL) m_pOwner->DoEvent(event);
            else CControlUI::DoEvent(event);
            return;
        }

        if (event.Type == UIEVENT_SETFOCUS)
        {
            return;
        }
        if (event.Type == UIEVENT_KILLFOCUS)
        {
            return;
        }
        if (event.Type == UIEVENT_BUTTONDOWN || event.Type == UIEVENT_DBLCLICK)
        {
            if (!IsEnabled()) return;

            m_nLastScrollOffset = 0;
            m_nScrollRepeatDelay = 0;
            m_pManager->SetTimer(this, DEFAULT_TIMERID, 50U);

            if (::PtInRect(&m_rcButton1, event.ptMouse))
            {
                m_uButton1State |= UISTATE_PUSHED;
                if (!m_bHorizontal)
                {
                    if (m_pOwner != NULL) m_pOwner->LineUp();
                    else SetScrollPos(m_nScrollPos - GetLineSize());
                }
                else
                {
                    if (m_pOwner != NULL) m_pOwner->LineLeft();
                    else SetScrollPos(m_nScrollPos - GetLineSize());
                }
            }
            else if (::PtInRect(&m_rcButton2, event.ptMouse))
            {
                m_uButton2State |= UISTATE_PUSHED;
                if (!m_bHorizontal)
                {
                    if (m_pOwner != NULL) m_pOwner->LineDown();
                    else SetScrollPos(m_nScrollPos + GetLineSize());
                }
                else
                {
                    if (m_pOwner != NULL) m_pOwner->LineRight();
                    else SetScrollPos(m_nScrollPos + GetLineSize());
                }
            }
            else if (::PtInRect(&m_rcThumb, event.ptMouse))
            {
                m_uThumbState |= UISTATE_CAPTURED | UISTATE_PUSHED;
                ptLastMouse = event.ptMouse;
                m_nLastScrollPos = m_nScrollPos;
            }
            else
            {
                if (!m_bHorizontal)
                {
                    if (event.ptMouse.y < m_rcThumb.top)
                    {
                        if (m_pOwner != NULL) m_pOwner->PageUp();
                        else SetScrollPos(m_nScrollPos + m_rcItem.top - m_rcItem.bottom);
                    }
                    else if (event.ptMouse.y > m_rcThumb.bottom)
                    {
                        if (m_pOwner != NULL) m_pOwner->PageDown();
                        else SetScrollPos(m_nScrollPos - m_rcItem.top + m_rcItem.bottom);
                    }
                }
                else
                {
                    if (event.ptMouse.x < m_rcThumb.left)
                    {
                        if (m_pOwner != NULL) m_pOwner->PageLeft();
                        else SetScrollPos(m_nScrollPos + m_rcItem.left - m_rcItem.right);
                    }
                    else if (event.ptMouse.x > m_rcThumb.right)
                    {
                        if (m_pOwner != NULL) m_pOwner->PageRight();
                        else SetScrollPos(m_nScrollPos - m_rcItem.left + m_rcItem.right);
                    }
                }
            }
            return;
        }
        if (event.Type == UIEVENT_BUTTONUP)
        {
            m_nScrollRepeatDelay = 0;
            m_nLastScrollOffset = 0;
            m_pManager->KillTimer(this, DEFAULT_TIMERID);

            if ((m_uThumbState & UISTATE_CAPTURED) != 0)
            {
                m_uThumbState &= ~(UISTATE_CAPTURED | UISTATE_PUSHED);
                Invalidate();
            }
            else if ((m_uButton1State & UISTATE_PUSHED) != 0)
            {
                m_uButton1State &= ~UISTATE_PUSHED;
                Invalidate();
            }
            else if ((m_uButton2State & UISTATE_PUSHED) != 0)
            {
                m_uButton2State &= ~UISTATE_PUSHED;
                Invalidate();
            }
            return;
        }
        if (event.Type == UIEVENT_MOUSEMOVE)
        {
            if ((m_uThumbState & UISTATE_CAPTURED) != 0)
            {
                if (!m_bHorizontal)
                {

                    int vRange = m_rcItem.bottom - m_rcItem.top - m_rcThumb.bottom + m_rcThumb.top;
                    if (m_bShowButton1)
                        vRange -= m_cxyFixed.cx;
                    if (m_bShowButton2)
                        vRange -= m_cxyFixed.cx;

                    if (vRange != 0)
                        m_nLastScrollOffset = (event.ptMouse.y - ptLastMouse.y) * m_nRange / vRange;

                }
                else
                {

                    int hRange = m_rcItem.right - m_rcItem.left - m_rcThumb.right + m_rcThumb.left;
                    if (m_bShowButton1)
                        hRange -= m_cxyFixed.cy;
                    if (m_bShowButton2)
                        hRange -= m_cxyFixed.cy;

                    if (hRange != 0)
                        m_nLastScrollOffset = (event.ptMouse.x - ptLastMouse.x) * m_nRange / hRange;
                }
            }
            else
            {
                if ((m_uThumbState & UISTATE_HOT) != 0)
                {
                    if (!::PtInRect(&m_rcThumb, event.ptMouse))
                    {
                        m_uThumbState &= ~UISTATE_HOT;
                        Invalidate();
                    }
                }
                else
                {
                    if (!IsEnabled()) return;
                    if (::PtInRect(&m_rcThumb, event.ptMouse))
                    {
                        m_uThumbState |= UISTATE_HOT;
                        Invalidate();
                    }
                }
            }
            return;
        }
        if (event.Type == UIEVENT_CONTEXTMENU)
        {
            return;
        }
        if (event.Type == UIEVENT_TIMER && event.wParam == DEFAULT_TIMERID)
        {
            ++m_nScrollRepeatDelay;
            if ((m_uThumbState & UISTATE_CAPTURED) != 0)
            {
                if (!m_bHorizontal)
                {
                    if (m_pOwner != NULL) m_pOwner->SetScrollPos(CDuiSize(m_pOwner->GetScrollPos().cx, \
                        m_nLastScrollPos + m_nLastScrollOffset));
                    else SetScrollPos(m_nLastScrollPos + m_nLastScrollOffset);
                }
                else
                {
                    if (m_pOwner != NULL) m_pOwner->SetScrollPos(CDuiSize(m_nLastScrollPos + m_nLastScrollOffset, \
                        m_pOwner->GetScrollPos().cy));
                    else SetScrollPos(m_nLastScrollPos + m_nLastScrollOffset);
                }
                Invalidate();
            }
            else if ((m_uButton1State & UISTATE_PUSHED) != 0)
            {
                if (m_nScrollRepeatDelay <= 5) return;
                if (!m_bHorizontal)
                {
                    if (m_pOwner != NULL) m_pOwner->LineUp();
                    else SetScrollPos(m_nScrollPos - GetLineSize());
                }
                else
                {
                    if (m_pOwner != NULL) m_pOwner->LineLeft();
                    else SetScrollPos(m_nScrollPos - GetLineSize());
                }
            }
            else if ((m_uButton2State & UISTATE_PUSHED) != 0)
            {
                if (m_nScrollRepeatDelay <= 5) return;
                if (!m_bHorizontal)
                {
                    if (m_pOwner != NULL) m_pOwner->LineDown();
                    else SetScrollPos(m_nScrollPos + GetLineSize());
                }
                else
                {
                    if (m_pOwner != NULL) m_pOwner->LineRight();
                    else SetScrollPos(m_nScrollPos + GetLineSize());
                }
            }
            else
            {
                if (m_nScrollRepeatDelay <= 5) return;
                POINT pt = { 0 };
                ::GetCursorPos(&pt);
                ::ScreenToClient(m_pManager->GetPaintWindow(), &pt);
                if (!m_bHorizontal)
                {
                    if (pt.y < m_rcThumb.top)
                    {
                        if (m_pOwner != NULL) m_pOwner->PageUp();
                        else SetScrollPos(m_nScrollPos + m_rcItem.top - m_rcItem.bottom);
                    }
                    else if (pt.y > m_rcThumb.bottom)
                    {
                        if (m_pOwner != NULL) m_pOwner->PageDown();
                        else SetScrollPos(m_nScrollPos - m_rcItem.top + m_rcItem.bottom);
                    }
                }
                else
                {
                    if (pt.x < m_rcThumb.left)
                    {
                        if (m_pOwner != NULL) m_pOwner->PageLeft();
                        else SetScrollPos(m_nScrollPos + m_rcItem.left - m_rcItem.right);
                    }
                    else if (pt.x > m_rcThumb.right)
                    {
                        if (m_pOwner != NULL) m_pOwner->PageRight();
                        else SetScrollPos(m_nScrollPos - m_rcItem.left + m_rcItem.right);
                    }
                }
            }
            return;
        }
        if (event.Type == UIEVENT_MOUSEENTER)
        {
            if (::PtInRect(&m_rcItem, event.ptMouse))
            {
                if (IsEnabled())
                {
                    m_uButton1State |= UISTATE_HOT;
                    m_uButton2State |= UISTATE_HOT;
                    if (::PtInRect(&m_rcThumb, event.ptMouse)) m_uThumbState |= UISTATE_HOT;
                    Invalidate();
                }
            }
        }
        if (event.Type == UIEVENT_MOUSELEAVE)
        {
            if (::PtInRect(&m_rcItem, event.ptMouse))
            {
                if (IsEnabled())
                {
                    m_uButton1State &= ~UISTATE_HOT;
                    m_uButton2State &= ~UISTATE_HOT;
                    m_uThumbState &= ~UISTATE_HOT;
                    Invalidate();
                }
                if (m_pManager) m_pManager->RemoveMouseLeaveNeeded(this);
            }
            else
            {
                if (m_pManager) m_pManager->AddMouseLeaveNeeded(this);
                return;
            }
        }

        if (m_pOwner != NULL) 
            m_pOwner->DoEvent(event); 
        else 
            CControlUI::DoEvent(event);
    }

    void CScrollBarUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
    {
        if (_tcscmp(pstrName, _T("button1color")) == 0)
        {
            while (*pstrValue > _T('\0') && *pstrValue <= _T(' ')) pstrValue = ::CharNext(pstrValue);
            if (*pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
            LPTSTR pstr = NULL;
            DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
            SetButton1Color(clrColor);
        }
        else if (_tcscmp(pstrName, _T("button1normalimage")) == 0) SetButton1NormalImage(pstrValue);
        else if (_tcscmp(pstrName, _T("button1hotimage")) == 0) SetButton1HotImage(pstrValue);
        else if (_tcscmp(pstrName, _T("button1pushedimage")) == 0) SetButton1PushedImage(pstrValue);
        else if (_tcscmp(pstrName, _T("button1disabledimage")) == 0) SetButton1DisabledImage(pstrValue);
        else if (_tcscmp(pstrName, _T("button2color")) == 0)
        {
            while (*pstrValue > _T('\0') && *pstrValue <= _T(' ')) pstrValue = ::CharNext(pstrValue);
            if (*pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
            LPTSTR pstr = NULL;
            DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
            SetButton2Color(clrColor);
        }
        else if (_tcscmp(pstrName, _T("button2normalimage")) == 0) SetButton2NormalImage(pstrValue);
        else if (_tcscmp(pstrName, _T("button2hotimage")) == 0) SetButton2HotImage(pstrValue);
        else if (_tcscmp(pstrName, _T("button2pushedimage")) == 0) SetButton2PushedImage(pstrValue);
        else if (_tcscmp(pstrName, _T("button2disabledimage")) == 0) SetButton2DisabledImage(pstrValue);
        else if (_tcscmp(pstrName, _T("thumbcolor")) == 0)
        {
            while (*pstrValue > _T('\0') && *pstrValue <= _T(' ')) pstrValue = ::CharNext(pstrValue);
            if (*pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
            LPTSTR pstr = NULL;
            DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
            SetThumbColor(clrColor);
        }
        else if (_tcscmp(pstrName, _T("thumbnormalimage")) == 0) SetThumbNormalImage(pstrValue);
        else if (_tcscmp(pstrName, _T("thumbhotimage")) == 0) SetThumbHotImage(pstrValue);
        else if (_tcscmp(pstrName, _T("thumbpushedimage")) == 0) SetThumbPushedImage(pstrValue);
        else if (_tcscmp(pstrName, _T("thumbdisabledimage")) == 0) SetThumbDisabledImage(pstrValue);
        else if (_tcscmp(pstrName, _T("railnormalimage")) == 0) SetRailNormalImage(pstrValue);
        else if (_tcscmp(pstrName, _T("railhotimage")) == 0) SetRailHotImage(pstrValue);
        else if (_tcscmp(pstrName, _T("railpushedimage")) == 0) SetRailPushedImage(pstrValue);
        else if (_tcscmp(pstrName, _T("raildisabledimage")) == 0) SetRailDisabledImage(pstrValue);
        else if (_tcscmp(pstrName, _T("bknormalimage")) == 0) SetBkNormalImage(pstrValue);
        else if (_tcscmp(pstrName, _T("bkhotimage")) == 0) SetBkHotImage(pstrValue);
        else if (_tcscmp(pstrName, _T("bkpushedimage")) == 0) SetBkPushedImage(pstrValue);
        else if (_tcscmp(pstrName, _T("bkdisabledimage")) == 0) SetBkDisabledImage(pstrValue);
        else if (_tcscmp(pstrName, _T("hor")) == 0) SetHorizontal(_tcscmp(pstrValue, _T("true")) == 0);
        else if (_tcscmp(pstrName, _T("linesize")) == 0) SetLineSize(_ttoi(pstrValue));
        else if (_tcscmp(pstrName, _T("range")) == 0) SetScrollRange(_ttoi(pstrValue));
        else if (_tcscmp(pstrName, _T("value")) == 0) SetScrollPos(_ttoi(pstrValue));
        else if (_tcscmp(pstrName, _T("scrollunit")) == 0) SetScrollUnit(_ttoi(pstrValue));
        else if (_tcscmp(pstrName, _T("showbutton1")) == 0) SetShowButton1(_tcscmp(pstrValue, _T("true")) == 0);
        else if (_tcscmp(pstrName, _T("showbutton2")) == 0) SetShowButton2(_tcscmp(pstrValue, _T("true")) == 0);
        else CControlUI::SetAttribute(pstrName, pstrValue);
    }

    bool CScrollBarUI::DoPaint(HDC hDC, const RECT& rcPaint, CControlUI* pStopControl)
    {
        PaintBkColor(hDC);
        PaintBkImage(hDC);
        PaintBk(hDC);
        PaintButton1(hDC);
        PaintButton2(hDC);
        PaintThumb(hDC);
        PaintRail(hDC);
        PaintBorder(hDC);
        return true;
    }

    void CScrollBarUI::PaintBk(HDC hDC)
    {
        if (!IsEnabled()) m_uThumbState |= UISTATE_DISABLED;
        else m_uThumbState &= ~UISTATE_DISABLED;

        if ((m_uThumbState & UISTATE_DISABLED) != 0)
        {
            if (DrawImage(hDC, m_diBkDisabled)) return;
        }
        else if ((m_uThumbState & UISTATE_PUSHED) != 0)
        {
            if (DrawImage(hDC, m_diBkPushed)) return;
        }
        else if ((m_uThumbState & UISTATE_HOT) != 0)
        {
            if (DrawImage(hDC, m_diBkHot)) return;
        }

        if (DrawImage(hDC, m_diBkNormal)) return;
    }

    void CScrollBarUI::PaintButton1(HDC hDC)
    {
        if (!m_bShowButton1) return;

        if (!IsEnabled()) m_uButton1State |= UISTATE_DISABLED;
        else m_uButton1State &= ~UISTATE_DISABLED;

        RECT rc = { 0 };
        rc.left = m_rcButton1.left - m_rcItem.left;
        rc.top = m_rcButton1.top - m_rcItem.top;
        rc.right = m_rcButton1.right - m_rcItem.left;
        rc.bottom = m_rcButton1.bottom - m_rcItem.top;

        if (m_dwButton1Color != 0)
        {
            if (m_dwButton1Color >= 0xFF000000) CRenderEngine::DrawColor(hDC, m_rcButton1, GetAdjustColor(m_dwButton1Color));
            else CRenderEngine::DrawColor(hDC, m_rcButton1, GetAdjustColor(m_dwButton1Color));
        }

        if ((m_uButton1State & UISTATE_DISABLED) != 0)
        {
            m_diButton1Disabled.rcDestOffset = rc;
            if (DrawImage(hDC, m_diButton1Disabled)) return;
        }
        else if ((m_uButton1State & UISTATE_PUSHED) != 0)
        {
            m_diButton1Pushed.rcDestOffset = rc;
            if (DrawImage(hDC, m_diButton1Pushed)) return;
        }
        else if ((m_uButton1State & UISTATE_HOT) != 0)
        {
            m_diButton1Hot.rcDestOffset = rc;
            if (DrawImage(hDC, m_diButton1Hot)) return;
        }

        m_diButton1Normal.rcDestOffset = rc;
        if (DrawImage(hDC, m_diButton1Normal)) return;
    }

    void CScrollBarUI::PaintButton2(HDC hDC)
    {
        if (!m_bShowButton2) return;

        if (!IsEnabled()) m_uButton2State |= UISTATE_DISABLED;
        else m_uButton2State &= ~UISTATE_DISABLED;

        RECT rc = { 0 };
        rc.left = m_rcButton2.left - m_rcItem.left;
        rc.top = m_rcButton2.top - m_rcItem.top;
        rc.right = m_rcButton2.right - m_rcItem.left;
        rc.bottom = m_rcButton2.bottom - m_rcItem.top;

        if (m_dwButton2Color != 0)
        {
            if (m_dwButton2Color >= 0xFF000000) CRenderEngine::DrawColor(hDC, m_rcButton2, GetAdjustColor(m_dwButton2Color));
            else CRenderEngine::DrawColor(hDC, m_rcButton2, GetAdjustColor(m_dwButton2Color));
        }

        if ((m_uButton2State & UISTATE_DISABLED) != 0)
        {
            m_diButton2Disabled.rcDestOffset = rc;
            if (DrawImage(hDC, m_diButton2Disabled)) return;
        }
        else if ((m_uButton2State & UISTATE_PUSHED) != 0)
        {
            m_diButton2Pushed.rcDestOffset = rc;
            if (DrawImage(hDC, m_diButton2Pushed)) return;
        }
        else if ((m_uButton2State & UISTATE_HOT) != 0)
        {
            m_diButton2Hot.rcDestOffset = rc;
            if (DrawImage(hDC, m_diButton2Hot)) return;
        }

        m_diButton2Normal.rcDestOffset = rc;
        if (DrawImage(hDC, m_diButton2Normal)) return;
    }

    void CScrollBarUI::PaintThumb(HDC hDC)
    {
        if (m_rcThumb.left == 0 && m_rcThumb.top == 0 && m_rcThumb.right == 0 && m_rcThumb.bottom == 0) return;
        if (!IsEnabled()) m_uThumbState |= UISTATE_DISABLED;
        else m_uThumbState &= ~UISTATE_DISABLED;

        RECT rc = { 0 };
        rc.left = m_rcThumb.left - m_rcItem.left;
        rc.top = m_rcThumb.top - m_rcItem.top;
        rc.right = m_rcThumb.right - m_rcItem.left;
        rc.bottom = m_rcThumb.bottom - m_rcItem.top;

        if (m_dwThumbColor != 0)
        {
            if (m_dwThumbColor >= 0xFF000000) CRenderEngine::DrawColor(hDC, m_rcThumb, GetAdjustColor(m_dwThumbColor));
            else CRenderEngine::DrawColor(hDC, m_rcThumb, GetAdjustColor(m_dwThumbColor));
        }

        if ((m_uThumbState & UISTATE_DISABLED) != 0)
        {
            m_diThumbDisabled.rcDestOffset = rc;
            if (DrawImage(hDC, m_diThumbDisabled)) return;
        }
        else if ((m_uThumbState & UISTATE_PUSHED) != 0)
        {
            m_diThumbPushed.rcDestOffset = rc;
            if (DrawImage(hDC, m_diThumbPushed)) return;
        }
        else if ((m_uThumbState & UISTATE_HOT) != 0)
        {
            m_diThumbHot.rcDestOffset = rc;
            if (DrawImage(hDC, m_diThumbHot)) return;
        }
        m_diThumbNormal.rcDestOffset = rc;
        if (DrawImage(hDC, m_diThumbNormal)) return;
    }

    void CScrollBarUI::PaintRail(HDC hDC)
    {
        if (m_rcThumb.left == 0 && m_rcThumb.top == 0 && m_rcThumb.right == 0 && m_rcThumb.bottom == 0) return;
        if (!IsEnabled()) m_uThumbState |= UISTATE_DISABLED;
        else m_uThumbState &= ~UISTATE_DISABLED;

        RECT rc = { 0 };
        if (!m_bHorizontal)
        {
            rc.left = m_rcThumb.left - m_rcItem.left;
            rc.top = (m_rcThumb.top + m_rcThumb.bottom) / 2 - m_rcItem.top - m_cxyFixed.cx / 2;
            rc.right = m_rcThumb.right - m_rcItem.left;
            rc.bottom = (m_rcThumb.top + m_rcThumb.bottom) / 2 - m_rcItem.top + m_cxyFixed.cx - m_cxyFixed.cx / 2;
        }
        else
        {
            rc.left = (m_rcThumb.left + m_rcThumb.right) / 2 - m_rcItem.left - m_cxyFixed.cy / 2;
            rc.top = m_rcThumb.top - m_rcItem.top;
            rc.right = (m_rcThumb.left + m_rcThumb.right) / 2 - m_rcItem.left + m_cxyFixed.cy - m_cxyFixed.cy / 2;
            rc.bottom = m_rcThumb.bottom - m_rcItem.top;
        }

        if ((m_uThumbState & UISTATE_DISABLED) != 0)
        {
            m_diRailDisabled.rcDestOffset = rc;
            if (DrawImage(hDC, m_diRailDisabled)) return;
        }
        else if ((m_uThumbState & UISTATE_PUSHED) != 0)
        {
            m_diRailPushed.rcDestOffset = rc;
            if (DrawImage(hDC, m_diRailPushed)) return;
        }
        else if ((m_uThumbState & UISTATE_HOT) != 0)
        {
            m_diRailHot.rcDestOffset = rc;
            if (DrawImage(hDC, m_diRailHot)) return;
        }
        m_diRailNormal.rcDestOffset = rc;
        if (DrawImage(hDC, m_diRailNormal)) return;
    }

} // namespace DuiLib
